{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# C++的指针"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. 指针"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.1 指针概念"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "① 指针的作用：可以通过指针间接访问内存。\n",
    "\n",
    "1. 内存编号是从0开始记录的，一般用十六进制数字表示。\n",
    "2. 可以利用指针变量保存地址。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2 指针变量定义和使用"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "① 指针变量定义语法：数据类型 + 变量名；"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <iostream>\n",
    "using namespace std;\n",
    "\n",
    "int main()\n",
    "{\n",
    "    //1、定义指针\n",
    "    int a = 10;\n",
    "\n",
    "    //指针定义的语法：数据类型 * 指针变量\n",
    "    int * p; //创建p为指针变量\n",
    "\n",
    "    //让指针记录变量a的地址\n",
    "    p = &a;  // &为取址符号\n",
    "\n",
    "    cout << \"a的地址为：\" << &a << endl;\n",
    "\n",
    "    cout << \"指针p为：\" << p << endl;  // 指针p存储的值 和变量a的地址是一样的\n",
    "\n",
    "    //2、使用指针\n",
    "    //可以通过解引用的方式来找到指针指向的内存\n",
    "    //指针前加 * 代表解引用，找到指针指向的内存中的数据\n",
    "\n",
    "    *p = 1000;  //通过*p访问内存，并修改内存的值\n",
    "    cout << \"a= \" << a << endl;\n",
    "    cout << \"*p：\" << *p << endl;\n",
    "\n",
    "    system(\"pause\");   //按任意键继续\n",
    "    \n",
    "    return 0;\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "运行结果：  \n",
    " - a的地址为：00FBFC78  \n",
    " - 指针p为：00FBFC78  \n",
    " - a= 1000  \n",
    " - *p：1000  \n",
    " - 请按任意键继续. . ."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.3 指针所占内存空间"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "① 在32位操作系统下，不管什么类型的指针都占4个字节的内存。\n",
    "\n",
    "② 在64位操作系统下，不管什么类型的指针都占8个字节的内存，但是实际开发环境一般都是32位操作系统下。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <iostream>\n",
    "using namespace std;\n",
    "\n",
    "int main()\n",
    "{\n",
    "    //指针所占内存空间\n",
    "    int a = 10;\n",
    "\n",
    "    /*\n",
    "    int * p; //p变量是 int * 数据类\n",
    "    p = &a;\n",
    "\n",
    "    等价于：\n",
    "    int * p = &a;\n",
    "    */\n",
    "\n",
    "    int * p = &a; \n",
    "\n",
    "    cout << \"sizeof(int * )= \" << sizeof(p) << endl;\n",
    "    cout << \"sizeof(int * )= \" << sizeof(int(*)) << endl;  \n",
    "    cout << \"sizeof(float * )= \" << sizeof(float(*)) << endl;\n",
    "    cout << \"sizeof(double * )= \" << sizeof(double(*)) << endl;\n",
    "    cout << \"sizeof(char * )= \" << sizeof(char(*)) << endl;\n",
    "\n",
    "    system(\"pause\");   //按任意键继续\n",
    "\n",
    "    return 0;\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "运行结果：  \n",
    " - sizeof(int * )= 4  \n",
    " - sizeof(int * )= 4  \n",
    " - sizeof(float * )= 4  \n",
    " - sizeof(double * )= 4  \n",
    " - sizeof(char * )= 4  \n",
    " - 请按任意键继续. . ."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.4 空指针"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "① 指针变量指向内存中编号为0的空间。\n",
    "\n",
    "② 用途：初始化指针变量。\n",
    "\n",
    "③ 空指针指向的内存是不可以访问的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <iostream>\n",
    "using namespace std;\n",
    "\n",
    "int main()\n",
    "{\n",
    "    //空指针\n",
    "    //1、空指针用于给指针变量进行初始化\n",
    "    int* p = NULL;\n",
    "\n",
    "    //2、空指针是不可以进行访问的\n",
    "    //0~255之间的内存编号是系统占用的，因此不可以访问。\n",
    "    *p = 100;  //对空指针解引用，然后操作它，这样是报错的\n",
    "\n",
    "    system(\"pause\");   //按任意键继续\n",
    "\n",
    "    return 0;\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.5 野指针"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "① 野指针：指针变量指向非法的内存空间。\n",
    "\n",
    "② 野指针和空指针都不是我们申请的空间，所以不要访问。\n",
    "\n",
    "③ 例如，创建了一个整型变量a，是申请了一个整型变量的空间，由于是申请的空间，所以可以通过指针访问它。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <iostream>\n",
    "using namespace std;\n",
    "\n",
    "int main()\n",
    "{\n",
    "    //野指针\n",
    "    int* p = (int*)0x1100; // 0x1100是一个十六进制数，int*使得十六进制数强行转换为地址。\n",
    "                           // 拿指针随便指向并没有申请这个内存的访问权限的内存。\n",
    "\n",
    "    cout << *p << endl; // 报错，地址并没有申请，你还要去访问它，就会报错\n",
    "\n",
    "    system(\"pause\");   \n",
    "\n",
    "    return 0;\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.6 const修饰指针"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "① 看const右侧紧跟着的是指针还是常量，是指针就是常量指针，是常量就是指针常量。\n",
    "\n",
    "② 如果 const后面跟的是指针(*)，就不能做 *p=20 操作，即不能修改指针指向的值。\n",
    "\n",
    "③ 如果const 后面跟的常量(p)，就不能做 p = &b 操作，即不能修改指针的指向。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <iostream>\n",
    "using namespace std;\n",
    "\n",
    "int main()\n",
    "{\n",
    "    \n",
    "    int a = 10;\n",
    "    int b = 10;\n",
    "\n",
    "    //1、const修饰指针 常量指针\n",
    "    const int* p = &a;  // const(常量) *(指针) → 常量指针 \n",
    "    // *p = 20;  错误，常量指针 → 指针指向的值不可以改，指针的指向可以改\n",
    "    p = &b; // 正确\n",
    "\n",
    "    //2、const修饰指针 指针常量\n",
    "    int* const p2 = &a; // *(指针)const(常量) → 指针常量\n",
    "    *p2 = 100; //正确的\n",
    "    p2 = &b;  //错误，指针的指向不可以改，指针指向的 值可以改\n",
    "\n",
    "    //3、const修饰指针和常量\n",
    "    const int* const p3 = &a;\n",
    "    *p3 = 100;  //错误\n",
    "    p3 = &b;  //错误\n",
    "\n",
    "    system(\"pause\");   \n",
    "\n",
    "    return 0;\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.7 指针和数组"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "① 利用指针访问数组中元素。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <iostream>\n",
    "using namespace std;\n",
    "\n",
    "int main()\n",
    "{\n",
    "    \n",
    "    //指针和数组\n",
    "    //利用指针访问数组中的元素\n",
    "\n",
    "    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };\n",
    "    \n",
    "    cout << \"第一个元素为：\" << arr[0] << endl;\n",
    "\n",
    "    int* p = arr; //数组名arr就是数组的首地址\n",
    "\n",
    "    cout << \"利用指针访问第一个元素：\" << *p << endl;\n",
    "\n",
    "    p++;\n",
    "\n",
    "    cout << \"利用指针访问第二个元素：\" << *p << endl;\n",
    "\n",
    "    cout << \"利用指针遍历数组：\" << endl;\n",
    "\n",
    "    int* p2 = arr;\n",
    "    for (int i = 0; i < 10; i++) \n",
    "    {\n",
    "        //cout << arr[i] << endl;\n",
    "        cout << *p2 << endl;\n",
    "        p2++;\n",
    "\n",
    "    }\n",
    "    system(\"pause\");   \n",
    "\n",
    "    return 0;\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "运行结果：  \n",
    " - 第一个元素为：1  \n",
    " - 利用指针访问第一个元素：1  \n",
    " - 利用指针访问第二个元素：2  \n",
    " - 利用指针遍历数组：  \n",
    " - 1  \n",
    " - 2  \n",
    " - 3  \n",
    " - 4  \n",
    " - 5  \n",
    " - 6  \n",
    " - 7  \n",
    " - 8  \n",
    " - 9  \n",
    " - 10  \n",
    " - 请按任意键继续. . ."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.8 指针和函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "① 利用指针作函数的参数，可以修改实参的值。\n",
    "\n",
    "② 地址传递可以改变实参的数据，值传递不可以改变实参的值。\n",
    "\n",
    "③ 如果不想修改实参，就用值传递，如果想修改实参，就用地址传递。\n",
    "\n",
    "④ 代码例子中，temp的值会传递给 *p2 地址中的值，所以a、b实参的值改变了。"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <iostream>\n",
    "using namespace std;\n",
    "\n",
    "void swap(int* p1, int* p2)\n",
    "{\n",
    "    int temp = *p1;\n",
    "    *p1 = *p2;\n",
    "    *p2 = temp;\n",
    "}\n",
    "\n",
    "int main()\n",
    "{\n",
    "    //指针和函数\n",
    "    int a = 10;\n",
    "    int b = 20;\n",
    "\n",
    "    swap(&a, &b);\n",
    "\n",
    "    //如果是地址传递，可以修改实参，原来 a = 10；b = 20，地址传递后 a = 20，b = 10.\n",
    "    cout << \"a =\" << a << endl;\n",
    "    cout << \"b =\" << b << endl;\n",
    "    //如果是值传递，不可以修改实参，原来 a = 10；b = 20，值传递后 a = 10，b = 20.\n",
    "\n",
    "    system(\"pause\");\n",
    "\n",
    "    return 0;\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "运行结果：\n",
    " - a =20\n",
    " - b =10\n",
    " - 请按任意键继续. . ."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.9 指针配合数组和函数案例"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "案例描述：封装一个函数，利用冒泡排序，实现对整型数字的升序排列。  \n",
    "\n",
    "例如： int arr[10] = {4,3,6,9,1,2,10,8,7,5}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <iostream>\n",
    "using namespace std;\n",
    "\n",
    "//冒泡排序函数\n",
    "void bubbleSort(int * arr, int len)\n",
    "{\n",
    "    for (int i = 0; i < len - 1; i++)\n",
    "    {\n",
    "        for (int j = 0; j < len - i - 1; j++)\n",
    "        {\n",
    "            //如果j>j+1的值，交换数字\n",
    "            if (arr[j] > arr[j + 1])\n",
    "            {\n",
    "                int temp = arr[j];\n",
    "                arr[j] = arr[j + 1];\n",
    "                arr[j + 1] = temp;\n",
    "            }\n",
    "        }\n",
    "    }\n",
    "}\n",
    "\n",
    "//打印数组\n",
    "void printArray(int* arr, int len)\n",
    "{\n",
    "    for (int i = 0; i < len; i++)\n",
    "    {\n",
    "        cout << arr[i] << endl;\n",
    "    }\n",
    "}\n",
    "\n",
    "int main()\n",
    "{\n",
    "    //1、先创建数组\n",
    "    int arr[10] = { 4,3,6,1,2,9,10,8,7,5 };\n",
    "\n",
    "    //数组长度\n",
    "    int len = sizeof(arr) / sizeof(arr[0]);\n",
    "\n",
    "    //2、创建函数，实现冒泡排序\n",
    "    bubbleSort(arr, len);\n",
    "\n",
    "    //3、打印排序后的数组\n",
    "    printArray(arr, len);\n",
    "\n",
    "\n",
    "    system(\"pause\");\n",
    "    \n",
    "    return 0;\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "运行结果：  \n",
    " - 1  \n",
    " - 2  \n",
    " - 3  \n",
    " - 4  \n",
    " - 5  \n",
    " - 6  \n",
    " - 7  \n",
    " - 8  \n",
    " - 9  \n",
    " - 10  \n",
    " - 请按任意键继续. . ."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.6.3",
   "language": "python",
   "name": "python3.6.3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "384px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
